( function () {
/**
 * You can use this geometry to create a decal mesh, that serves different kinds of purposes.
 * e.g. adding unique details to models, performing dynamic visual environmental changes or covering seams.
 *
 * Constructor parameter:
 *
 * mesh — Any mesh object
 * position — Position of the decal projector
 * orientation — Orientation of the decal projector
 * size — Size of the decal projector
 *
 * reference: http://blog.wolfire.com/2009/06/how-to-project-decals/
 *
 */

class DecalGeometry extends THREE.BufferGeometry {
  constructor(mesh, position, orientation, size) {
    super(); // buffers

    const vertices = [];
    const normals = [];
    const uvs = []; // helpers

    const plane = new THREE.Vector3(); // this matrix represents the transformation of the decal projector

    const projectorMatrix = new THREE.Matrix4();
    projectorMatrix.makeRotationFromEuler(orientation);
    projectorMatrix.setPosition(position);
    const projectorMatrixInverse = new THREE.Matrix4();
    projectorMatrixInverse.copy(projectorMatrix).invert(); // generate buffers

    generate(); // build geometry

    this.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
    this.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
    this.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));

    function generate() {
      let decalVertices = [];
      const vertex = new THREE.Vector3();
      const normal = new THREE.Vector3(); // handle different geometry types

      if (mesh.geometry.isGeometry === true) {
        console.error('THREE.DecalGeometry no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.');
        return;
      }

      const geometry = mesh.geometry;
      const positionAttribute = geometry.attributes.position;
      const normalAttribute = geometry.attributes.normal; // first, create an array of 'DecalVertex' objects
      // three consecutive 'DecalVertex' objects represent a single face
      //
      // this data structure will be later used to perform the clipping

      if (geometry.index !== null) {
        // indexed THREE.BufferGeometry
        const index = geometry.index;

        for (let i = 0; i < index.count; i++) {
          vertex.fromBufferAttribute(positionAttribute, index.getX(i));
          normal.fromBufferAttribute(normalAttribute, index.getX(i));
          pushDecalVertex(decalVertices, vertex, normal);
        }
      } else {
        // non-indexed THREE.BufferGeometry
        for (let i = 0; i < positionAttribute.count; i++) {
          vertex.fromBufferAttribute(positionAttribute, i);
          normal.fromBufferAttribute(normalAttribute, i);
          pushDecalVertex(decalVertices, vertex, normal);
        }
      } // second, clip the geometry so that it doesn't extend out from the projector


      decalVertices = clipGeometry(decalVertices, plane.set(1, 0, 0));
      decalVertices = clipGeometry(decalVertices, plane.set(-1, 0, 0));
      decalVertices = clipGeometry(decalVertices, plane.set(0, 1, 0));
      decalVertices = clipGeometry(decalVertices, plane.set(0, -1, 0));
      decalVertices = clipGeometry(decalVertices, plane.set(0, 0, 1));
      decalVertices = clipGeometry(decalVertices, plane.set(0, 0, -1)); // third, generate final vertices, normals and uvs

      for (let i = 0; i < decalVertices.length; i++) {
        const decalVertex = decalVertices[i]; // create texture coordinates (we are still in projector space)

        uvs.push(0.5 + decalVertex.position.x / size.x, 0.5 + decalVertex.position.y / size.y); // transform the vertex back to world space

        decalVertex.position.applyMatrix4(projectorMatrix); // now create vertex and normal buffer data

        vertices.push(decalVertex.position.x, decalVertex.position.y, decalVertex.position.z);
        normals.push(decalVertex.normal.x, decalVertex.normal.y, decalVertex.normal.z);
      }
    }

    function pushDecalVertex(decalVertices, vertex, normal) {
      // transform the vertex to world space, then to projector space
      vertex.applyMatrix4(mesh.matrixWorld);
      vertex.applyMatrix4(projectorMatrixInverse);
      normal.transformDirection(mesh.matrixWorld);
      decalVertices.push(new DecalVertex(vertex.clone(), normal.clone()));
    }

    function clipGeometry(inVertices, plane) {
      const outVertices = [];
      const s = 0.5 * Math.abs(size.dot(plane)); // a single iteration clips one face,
      // which consists of three consecutive 'DecalVertex' objects

      for (let i = 0; i < inVertices.length; i += 3) {
        let total = 0;
        let nV1;
        let nV2;
        let nV3;
        let nV4;
        const d1 = inVertices[i + 0].position.dot(plane) - s;
        const d2 = inVertices[i + 1].position.dot(plane) - s;
        const d3 = inVertices[i + 2].position.dot(plane) - s;
        const v1Out = d1 > 0;
        const v2Out = d2 > 0;
        const v3Out = d3 > 0; // calculate, how many vertices of the face lie outside of the clipping plane

        total = (v1Out ? 1 : 0) + (v2Out ? 1 : 0) + (v3Out ? 1 : 0);

        switch (total) {
          case 0:
            {
              // the entire face lies inside of the plane, no clipping needed
              outVertices.push(inVertices[i]);
              outVertices.push(inVertices[i + 1]);
              outVertices.push(inVertices[i + 2]);
              break;
            }

          case 1:
            {
              // one vertex lies outside of the plane, perform clipping
              if (v1Out) {
                nV1 = inVertices[i + 1];
                nV2 = inVertices[i + 2];
                nV3 = clip(inVertices[i], nV1, plane, s);
                nV4 = clip(inVertices[i], nV2, plane, s);
              }

              if (v2Out) {
                nV1 = inVertices[i];
                nV2 = inVertices[i + 2];
                nV3 = clip(inVertices[i + 1], nV1, plane, s);
                nV4 = clip(inVertices[i + 1], nV2, plane, s);
                outVertices.push(nV3);
                outVertices.push(nV2.clone());
                outVertices.push(nV1.clone());
                outVertices.push(nV2.clone());
                outVertices.push(nV3.clone());
                outVertices.push(nV4);
                break;
              }

              if (v3Out) {
                nV1 = inVertices[i];
                nV2 = inVertices[i + 1];
                nV3 = clip(inVertices[i + 2], nV1, plane, s);
                nV4 = clip(inVertices[i + 2], nV2, plane, s);
              }

              outVertices.push(nV1.clone());
              outVertices.push(nV2.clone());
              outVertices.push(nV3);
              outVertices.push(nV4);
              outVertices.push(nV3.clone());
              outVertices.push(nV2.clone());
              break;
            }

          case 2:
            {
              // two vertices lies outside of the plane, perform clipping
              if (!v1Out) {
                nV1 = inVertices[i].clone();
                nV2 = clip(nV1, inVertices[i + 1], plane, s);
                nV3 = clip(nV1, inVertices[i + 2], plane, s);
                outVertices.push(nV1);
                outVertices.push(nV2);
                outVertices.push(nV3);
              }

              if (!v2Out) {
                nV1 = inVertices[i + 1].clone();
                nV2 = clip(nV1, inVertices[i + 2], plane, s);
                nV3 = clip(nV1, inVertices[i], plane, s);
                outVertices.push(nV1);
                outVertices.push(nV2);
                outVertices.push(nV3);
              }

              if (!v3Out) {
                nV1 = inVertices[i + 2].clone();
                nV2 = clip(nV1, inVertices[i], plane, s);
                nV3 = clip(nV1, inVertices[i + 1], plane, s);
                outVertices.push(nV1);
                outVertices.push(nV2);
                outVertices.push(nV3);
              }

              break;
            }

          case 3:
            {
              // the entire face lies outside of the plane, so let's discard the corresponding vertices
              break;
            }
        }
      }

      return outVertices;
    }

    function clip(v0, v1, p, s) {
      const d0 = v0.position.dot(p) - s;
      const d1 = v1.position.dot(p) - s;
      const s0 = d0 / (d0 - d1);
      const v = new DecalVertex(new THREE.Vector3(v0.position.x + s0 * (v1.position.x - v0.position.x), v0.position.y + s0 * (v1.position.y - v0.position.y), v0.position.z + s0 * (v1.position.z - v0.position.z)), new THREE.Vector3(v0.normal.x + s0 * (v1.normal.x - v0.normal.x), v0.normal.y + s0 * (v1.normal.y - v0.normal.y), v0.normal.z + s0 * (v1.normal.z - v0.normal.z))); // need to clip more values (texture coordinates)? do it this way:
      // intersectpoint.value = a.value + s * ( b.value - a.value );

      return v;
    }
  }

} // helper


class DecalVertex {
  constructor(position, normal) {
    this.position = position;
    this.normal = normal;
  }

  clone() {
    return new this.constructor(this.position.clone(), this.normal.clone());
  }

}

THREE.DecalGeometry = DecalGeometry;
THREE.DecalVertex = DecalVertex;
} )();
